<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Présentation des nouveautés de J2SE 5.0 - Articles - 1/1 - Java &amp; Solaris par le Laboratoire SUPINFO des technologies Sun </title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords />
        <author>Frédéric Chuong</author>
    </head>
    <body>
        <div class="chapter">
            <p>Java 2 Platform Standard Edition (J2SE) 5.0 ("Tiger") est la nouvelle évolution majeure du langage et de la plate-forme Java</p>
            <p>
                NOTE : La version externe de cette génération est la 5.0, mais sa version interne est désignée en tant que 1.5.0,
				comme décrit dans
                <a href="http://java.sun.com/j2se/naming_versioning_5_0.html" target="_blank">J2SE Naming and Versioning</a>
                .
            </p>
            <p>J2SE 5.0 s'appuie essentiellement sur les points suivants :</p>
            <ul>
                <li>
                    <a href="#ease">Facilité de développement</a>
                </li>
                <li>
                    <a href="#snp">Flexibilité et performance</a>
                </li>
                <li>
                    <a href="#mnm">Gestion et surveillance</a>
                </li>
                <li>
                    <a href="#dc">Desktop Client</a>
                </li>
            </ul>
            <p>Certaines fonctions, bien qu'importantes, ne correspondent pas à ces catégories et seront discutées à la fin de ce document :</p>
            <ul>
                <li>
                    <a href="#misc">Fonctions diverses</a>
                </li>
            </ul>
        </div>
        <div class="chapter">
            <h2>Facilité de développement</h2>
            <p>
                Les changements du langage visant à faciliter le développement sont les suivants : les types génériques, les metadata, l'autoboxing,
				boucle étendue (boucle for), les types énumérés, les imports statiques, un formatage d'entrées/sorties façon C, les arguments variables,
				des outils de gestion d'accès concurrents et la simplification de la génération d'interfaces
                <abbr title="Remote Method Invocation">RMI</abbr>
                .
            </p>
            <p>Ces fonctionnalités sont spécifiées dans les Java Specification Requests JSR-201, JSR-175 et JSR-14.</p>
            <p>La spécification de langage par défaut du compilateur javac est désormais la version 5.0 (1.5) de façon à ce qu'il ne soit pas
				nécessaire de spécifier l'option -source 1.5 comme il était nécessaire avec la version beta1.</p>
            <div class="subChapter">
                <h3>Metadata</h3>
                <p>Les metadata apportées par J2SE 5.0 permettent l'association de données additionnelles aux classes, interface, méthodes et membres.
					Ces données additionnelles, ou annotations, pourront être lues par le compilateur javac ou d'autres outils et, en fonction de la configuration,
					pourront être enregistrées dans les fichiers .class pour être disponible au moment de l'exécution, au moyen de l'API Java reflection.</p>
                <p>Une des raisons principales pour l'ajout des metadata à la plate-forme Java est de disposer, au moment du développement et au moment de l'exécution,
					d’une infrastructure commune permettant de réduire les efforts nécessaires au développement et au déploiement. Un outil pourra utiliser ces metadata pour générer
					du code additionnel ou apporter des informations supplémentaires au moment du débogage.</p>
                <p>
                    Il existe depuis la beta2 un outil permettant l'exploitation de ces annotations, il s'agit du programme apt.
					Il gère le nouveau jeu des API de réflexion ainsi que les annotations. Il permet la lecture, au moment de la compilation, des informations de structure.
					En premier lieu, il parcours les annotations pour générer de nouveaux fichiers source ou autre ;
					il peut ensuite procéder à la compilation des fichiers originaux et générés.
					Pour plus d'informations, vous pouvez vous référer au
                    <a href="http://java.sun.com/j2se/1.5.0/docs/guide/apt/" target="_blank">guide d'apt</a>
                    .
                </p>
                <p>L'exemple suivant montre l'utilisation des metadata, et peut être complété avec un AnnotationFactory pour apt, afin de générer du code
					ou de la documentation lors de la présence du tag d'annotation debug.</p>
                <textarea name="code" class="java">import java.lang.annotation.*;
					import java.lang.reflect.*;
					@Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @interface debug {
					boolean devbuild() default false;
					int counter();
					}
					public class MetaTest {
					final boolean production = true;
					@debug(devbuild=production,counter=1) public void testMethod() {
					}
					public static void main(String[] args) {
					MetaTest mt = new MetaTest();
					try {
					Annotation[] a = mt.getClass().getMethod("testMethod").getAnnotations();
					for (int i = 0; i
					&lt; a.length; i++) {
					System.out.println("a[" + i + "]=" + a[i] + " ");
					}
					} catch (NoSuchMethodException e) {
					System.out.println(e);
					}
					}
					}</textarea>
                <p>L'utilisation d'outils de traitement de metadata permet de réduire plusieurs tâches répétitives en de simple tag metadata.
					Par exemple, l'utilisation d'interface distantes lors de l'utilisation du service JAX-RPC peut se faire comme ci-dessous :</p>
                <p>
                    <b>Avant</b>
                </p>
                <textarea name="code" class="java">public interface PingIF extends Remote {
					public void ping() throws RemoteException;
					}
					public class Ping implements PingIF {
					public void ping() {
					}
					}</textarea>
                <p>
                    <b>Après</b>
                </p>
                <textarea name="code" class="java">public class Ping {
					public @remote void ping() {
					}
					}</textarea>
            </div>
            <div class="subChapter">
                <h3>Types génériques</h3>
                <p>Les types génériques constituent une large demande de la communauté Java et font désormais partie intégrante de J2SE 5.0.
					L'utilisation des types génériques sera, dans un premier temps, souvent liée à l'utilisation d’API comme Collection.
					Cette API permet a des objets comme les LinkedList, ArraysList et HashMap qui peuvent être utilisés conjointement avec différents types Java.
					L'exemple suivant utilise la librairie 1.4.2 ainsi que le mode de compilation par défaut de javac.</p>
                <textarea name="code" class="java">ArrayList list = new ArrayList();
					list.add(0, new Integer(42));
					int total = ((Integer) list.get(0)).intValue();</textarea>
                <p>Le cast en Integer de la dernière ligne est un exemple de transtypage que les types génériques permettent d'éviter.
					Le problème étant que l'API Collection dans la version 1.4.2 de J2SE utilise la classe Object pour stocker les objets de la Collection,
					ce qui veut dire qu'il n'est pas possible de détecter le futur type à la compilation. En cas de problème de transtypage,
					une ClassCastException sera levée au moment de l'exécution.</p>
                <p>Le même code avec la librairie des Collections génériques sera écrit comme ceci :</p>
                <textarea name="code" class="java">
                    ArrayList
                    <integer>
                        list =  new ArrayList
                        <integer>();
							list.add(0, new Integer(42));
							int total = list.get(0).intValue();</integer>
                    </integer>
                </textarea>
                <p>L'utilisateur d'une API générique n'a qu'à spécifier le type utilisé au moment de la compilation à l'aide de la notation
					&lt;&gt;.
					Il n'est plus nécessaire de procéder à des casts. Si vous essayez de rajouter un objet String à une collection typée en Integer,
					une erreur sera provoquée à la compilation.</p>
                <p>Les types génériques rendent toutefois possible l'utilisation de types multiples qui pourront être vérifiés au moment de la compilation.</p>
                <p>
                    La conception de votre propre API générique est un peu plus compliquée que leur utilisation.
					Vous pouvez vous référer à la source de la classe
                    <code>java.util.Collection</code>
                    pour vous y aider.
                </p>
            </div>
            <div class="subChapter">
                <h3>Autoboxing et Auto-Unboxing des types primitifs</h3>
                <p>La conversion des types primitifs, comme les int, boolean, et leurs équivalents objets, comme les Integer, Boolean , nécessite du développement dont on pourrait se passer,
					surtout si, par exemple, leurs utilisations ne se font que dans le cadre d'un appel de méthode de l'API des Collections.</p>
                <p>L'autoboxing et l'auto-unboxing des types Java primitifs permettent l'utilisation d'un code plus concis et compréhensif.
					Dans l'exemple suivant, un int sera stocké et récupéré d'une ArrayList. J2SE 5.0 laisse le travail de conversion vers et à partir d'un Integer au compilateur.</p>
                <p>
                    <b>Avant</b>
                </p>
                <textarea name="code" class="java">
                    ArrayList
                    <integer>
                        list = new ArrayList
                        <integer>();
							list.add(0, new Integer(42));
							int total = (list.get(0)).intValue();</integer>
                    </integer>
                </textarea>
                <p>
                    <b>Après</b>
                </p>
                <textarea name="code" class="java">
                    ArrayList
                    <integer>
                        list = new ArrayList
                        <integer>();
							list.add(0, 42);
							int total = list.get(0);</integer>
                    </integer>
                </textarea>
            </div>
            <div class="subChapter">
                <h3>Boucles étendues</h3>
                <p>La classe Iterator est très souvent utilisée avec l'API des Collections.
					Elle fournit un mécanisme de parcours séquentiel d'une Collection. Les nouvelles boucles étendues sont en mesure de remplacer leur utilisation.
					Le compilateur va générer le code nécessaire de la boucle et, avec les types génériques, il ne sera même plus nécessaire d'avoir recours au casting.</p>
                <p>
                    <b>Avant</b>
                </p>
                <textarea name="code" class="java">
                    ArrayList
                    <integer>
                        list = new ArrayList
                        <integer>();
							for (Iterator i = list.iterator(); i.hasNext();) {
							Integer value = (Integer) i.next();
							}</integer>
                    </integer>
                </textarea>
                <p>
                    <b>Après</b>
                </p>
                <textarea name="code" class="java">
                    ArrayList
                    <integer>
                        list = new ArrayList
                        <integer>();
							for (Integer i : list) { ... }</integer>
                    </integer>
                </textarea>
            </div>
            <div class="subChapter">
                <h3>Types énumérés</h3>
                <p>Les types énumérés permettent de remplacer l'utilisation de constantes static final. Si vous avez déjà utilisé l'identifiant enum dans vos applications,
					il vous sera nécessaire de le remplacer lors de la compilation avec javac -source 1.5 (ou -source 5).</p>
                <textarea name="code" class="java">public enum StopLight { red, amber, green };</textarea>
            </div>
            <div class="subChapter">
                <h3>Importations statiques</h3>
                <p>La fonction d'importation statique, utilisée avec "import static",
					permet de se référer à des constantes statiques d'une classe sans avoir besoin de s'y référer. Par exemple, au lieu de spécifier BorderLayout.CENTER,
					vous pourrez simplement utiliser CENTER.</p>
                <textarea name="code" class="java">import static java.awt.BorderLayout.*;
					getContentPane().add(new JPanel(), CENTER);</textarea>
            </div>
            <div class="subChapter">
                <h3>Sortie formatée</h3>
                <p>Il est désormais possible d'utiliser une syntaxe du type printf pour la génération de sortie formatée.
					Il sera ainsi possible d'adapter plus facilement des applications C qui utilisent ce type de formatage avec très peu, voire aucun changement.</p>
                <p>
                    La plupart des formatages de la fonction C printf sont disponibles, avec quelques formats supplémentaires pour les classes comme Date et BigInteger.
					Vous pouvez vous référer à la classe
                    <code>java.util.Formatter</code>
                    pour avoir plus d'informations. Bien que le caractère de nouvelle ligne UNIX '\n' soit accepté,
					il est recommandé d'utiliser la séquence %n en Java afin d'assurer une portabilité entre les différentes plate-formes.
                </p>
                <textarea name="code" class="java">System.out.printf("name count%n");
					System.out.printf("%s %5d%n", user, total);</textarea>
            </div>
            <div class="subChapter">
                <h3>Entrée formatée</h3>
                <p>L'API scanner met à notre disposition des fonctions pour la lecture de données à travers la console système, ou tout flux de données.
					L'exemple suivant lit une chaîne de caractères String, puis un nombre entier à partir de l'entrée standard.</p>
                <p>
                    Les méthodes comme next et nextInt de la classe Scanner bloqueront si aucune donnée n'est disponible. Si vous avez besoin de gérer des entrées plus complexes,
					il existe des algorithmes par motif dans la classe
                    <code>java.util.Formatter</code>
                    .
                </p>
                <textarea name="code" class="java">Scanner s = new Scanner(System.in);
					String param = s.next();
					int value = s.nextInt();
					s.close();</textarea>
            </div>
            <div class="subChapter">
                <h3>Arguments variables</h3>
                <p>Les arguments variables permettent de passer en paramètres d'une méthode un nombre variable d'arguments. Cette fonctionnalité s'utilise en spécifiant la notation ...
					et c'est elle qui permet l'utilisation de la fonction printf avec son nombre d'arguments variable.</p>
                <p>
                    <textarea name="code" class="java">void argtest(Object ... args) {
						for (int i = 0; i
						&lt; args.length; i++) {
						System.out.println(args[i]);
						}
						}
						argtest("test", "data");</textarea>
                </p>
            </div>
            <div class="subChapter">
                <h3>Concurrency Utilities</h3>
                <p>La librairie d'outils de gestion de concurrence, créée par Doug Lea dans la JSR-166, fait partie de J2SE 5.0.
					Elle permet une gestion de threads de haut niveau, comme les executors qui constituent un framework de gestion des threads,
					des files d'attentes pleinement compatibles avec les threads, des Timers, des verrous, et d'autres techniques de synchronisation.</p>
                <p />
                <p>
                    Un des verrous les plus connus est le sémaphore. Un sémaphore peut être utilisée de la même manière que la méthode wait,
					afin de restreindre l'accès à une portion de code. Les sémaphores sont plus flexibles et peuvent autoriser un certain nombre de threads à procéder à des accès concurrents,
					ainsi que de tester si un verrou est disponible avant d'en prendre possession. L'exemple suivant montre l'utilisation d'un sémaphore unique.
					Vous pourrez avoir plus d'informations dans le package
                    <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/package-tree.html" target="_blank">
                        <code>java.util.concurrent</code>
                    </a>
                    .
                </p>
                <p>
                    <textarea name="code" class="java">final private Semaphore s = new Semaphore(1, true);
						s.acquireUninterruptibly(); // pour un appel non bloquant, utilisez s.acquire()
						try {
						balance = balance + 10; // valeur protégée par le sémaphore
						} finally {
						s.release(); // libère le sémaphore
						}</textarea>
                </p>
            </div>
            <div class="subChapter">
                <h3>RMIC -- Le compilateur RMI</h3>
                <p>
                    Vous n'avez plus besoin d'utiliser rmic, le compilateur rmi, pour générer la plupart de vos connecteurs d'interfaces distantes.
					L'introduction des proxy dynamiques permet la découverte d'informations qui devaient jusqu'à présent être fournies par les connecteurs au moment de l'exécution. Pour plus d'informations, référez-vous à la page
                    <a href="http://java.sun.com/j2se/1.5.0/docs/guide/rmi/relnotes.html" target="_blank">RMI release notes</a>
                    .
                </p>
                <p />
            </div>
            <a name="snp" />
        </div>
        <div class="chapter">
            <h2>Flexibilité et performance</h2>
            <p>La version 5.0 de J2SE fournit de plus grandes flexibilités et performances, avec un temps de démarrage et une charge mémoire améliorés,
				ce qui facilite le déploiement et la rapidité des applications.</p>
            <p>
                Une des principales mises à jour est l'ajout du partage de données entre classes dans la JVM HotSpot.
				Cette technologie permet non seulement le partage de données en lecture-seule entre diverses
                <abbr title="Java Virtual Machine">JVM</abbr>
                s'exécutant en même temps,
				mais permet également un temps de démarrage plus court, car les classes des
                <abbr title="Java Virtual Machine">JVM</abbr>
                sont pré-compressées.
            </p>
            <p>
                L'optimisation des performances avec J2SE 5.0 étant nouvelle, si vous aviez l'habitude d'utiliser des paramètres spécialisés de la
                <abbr title="Java Virtual Machine">JVM</abbr>
                dans les versions précédentes,
				il sera sans doute nécessaire de revoir vos paramètres avec moins, voire aucune option supplémentaire avec la version 5.0.
            </p>
            <a name="mnm" />
        </div>
        <div class="chapter">
            <h2>Gestion et surveillance</h2>
            <p>La gestion et la surveillance sont des points clés pour la politique de qualité RAS (Reliability, Availability, Serviceability) de la plate-forme Java.</p>
            <p>
                J2SE 5.0 met à disposition un panel d'outils de gestion et de surveillance : instrumentation de la machine virtuelle Java,
				le framework Java Management Extensions (JMX) et des protocoles d'accès distants. Pour plus d'informations,
				référez-vous à
                <a href="http://java.sun.com/j2se/1.5.0/docs/guide/management/index.html" target="_blank">Management and Monitoring release notes</a>
                .
            </p>
            <p>
                L'API de gestion et surveillance de la
                <abbr title="Java Virtual Machine">JVM</abbr>
                comprend un grand nombre d'instrumentations concernant la
                <abbr title="Java Virtual Machine">JVM</abbr>
                .
				Ces informations sont accessibles via JMX MBeans et peuvent être consultées localement au sein de l'espace d'adressage Java
				ou à distance à l'aide de l'interface
                <abbr title="Java Management Extensions">JMX</abbr>
                et d'autres outils
                <abbr title="Simple Network Management Protocol">SNMP</abbr>
                standard.
            </p>
            <p>
                Une fonction des plus utiles est la détection de faible mémoire disponible. JMX MBeans peut ainsi avertir des listeners abonnés
				quand un certain seuil est dépassé. Pour plus d'informations, référez-vous à
                <a href="http://java.sun.com/j2se/1.5.0/docs/api/javax/management/package-summary.html" target="_blank">javax.management</a>
                et
                <code>java.lang.management</code>
                .
            </p>
            <p>
                J2SE 5.0 fournit de quoi gérer à distance la
                <abbr title="Java Virtual Machine">JVM</abbr>
                . Par exemple, pour démarrer une application de façon à la surveiller avec JConsole
				depuis la même machine, vous pouvez utiliser la syntaxe suivante :
            </p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">java -Dcom.sun.management.jmxremote -jar Java2Demo.jar</span>
                <br />
            </div>
            <p>et pour la surveiller à distance à l'aide de JMX, sans authentification :</p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">java  -Dcom.sun.management.jmxremote.port=5001
					-Dcom.sun.management.jmxremote.ssl=false
					-Dcom.sun.management.jmxremote.authenticate=false -jar Java2Demo.jar</span>
            </div>
            <p>
                Voici un exemple d'utilisation de la nouvelle
                <abbr title="Application Programming Interface">API</abbr>
                , qui permet de connaître la charge mémoire de la
                <abbr title="Java Virtual Machine">JVM</abbr>
                HotSpot :
            </p>
            <textarea name="code" class="java">
                import java.lang.management.*;
				import java.util.*;
				public class MemTest {
				public static void main(String args[]) {
				List
                <memorypoolmxbean>pools = ManagementFactory.getMemoryPoolMXBeans();
					for (MemoryPoolMXBean p: pools) {
					System.out.println("Memory type=" + p.getType() + " Memory usage=" + p.getUsage());
					}
					}
					}</memorypoolmxbean>
            </textarea>
            <div class="subChapter">
                <h3>Nouvelle API de profiling de la JVMNew JVM Profiling API (JSR-163)</h3>
                <p>
                    Cette version propose une nouvelle
                    <abbr title="Application Programming Interface">API</abbr>
                    native de profiling appelée
                    <abbr title="Java Virtual Machine Tool Interface">JVMTI</abbr>
                    . Cette API a été demandée par la JSR-163 afin d'obtenir
					une interface de profiling améliorée.
                    <abbr title="Java Virtual Machine Tool Interface">JVMTI</abbr>
                    a pour but de prendre en charge une grande partie des outils de gestion des processus, ce qui,
					en plus de permettre le profiling, ajoute des outils de surveillance, débogage et d'analyse.
                </p>
                <p>
                    Un mécanisme d'instrumentation du bytecode est également inclus, il se nomme Java Programming Language Instrumentation Services (JPLIS).
					Il autorise les outils d'analyse à effectuer du profiling uniquement où cela est nécessaire. L'avantage de cette technique est qu'elle autorise une analyse
					plus précise et limite les interférences possibles entre les outils de profiling s'exécutant dans la même
                    <abbr title="Java Virtual Machine">JVM</abbr>
                    . L'instrumentation peut également être
					dynamiquement générée au moment de l'exécution ou au moment du chargement des classes, pour ensuite être traitée sous forme de fichiers class.
                </p>
                <p>
                    L'exemple suivant crée un hook d'instrumentation permettant de charger une version modifiée de la classe présente sur le disque. Pour exécuter ce test,
					lancez le
                    <abbr title="Java Runtime Environment">JRE</abbr>
                    avec java -javaagent:myBCI BCITest
                </p>
                <textarea name="code" class="java">// Fichier myBCI.java
					import java.lang.instrument.Instrumentation;
					public class myBCI {
					private static Instrumentation instCopy;
					public static void premain(String options, Instrumentation inst) {
					instCopy = inst;
					}
					public static Instrumentation getInstrumentation() {
					return instCopy;
					}
					}
					// Fichier BCITest.java
					import java.nio.*;
					import java.io.*;
					import java.nio.channels.*;
					import java.lang.instrument.*;
					public class BCITest {
					public static void main (String[] args) {
					try {
					OriginalClass mc = new OriginalClass();
					mc.message();
					FileChannel fc = new FileInputStream(
					new File("modified" + File.separator + "OriginalClass.class")).getChannel();
					ByteBuffer buf = fc.map(FileChannel.MapMode.READ_ONLY, 0, (int)fc.size());
					byte[] classBuffer  = new byte[buf.capacity()];
					buf.get(classBuffer, 0, classBuffer.length);
					myBCI.getInstrumentation().redefineClasses(
					new ClassDefinition[] {
					new ClassDefinition(mc.getClass(), classBuffer)});
					mc.message();
					} catch (Exception e) {}
					}
					}
					// OriginalClass.java
					// Compilez dans le répertoire courant
					// Copiez la source dans le répertoire modified, changez le message et recompilez
					public class OriginalClass {
					public void message() {
					System.out.println("OriginalClass");
					}
					}</textarea>
            </div>
            <div class="subChapter">
                <h3>Diagnostics améliorés</h3>
                <p>L'utilisation de l'historique des appels (Stack Trace) a, jusqu'à présent, été inappropriée quand l'application ne contient pas de fenêtre de console.
					Deux nouvelles APIs, getStackTrace et Thread.getAllStackTraces permettent d'obtenir cette information dans vos programmes.</p>
                <textarea name="code" class="java">StackTraceElement e[] = Thread.currentThread().getStackTrace();
					for (int i = 0; i
					&lt; e.length; i++) {
					System.out.println(e[i]);
					}
					System.out.println("\n" + Thread.getAllStackTraces());</textarea>
                <p>
                    La JVM HotSpot inclut une gestion des erreurs fatales, afin de pouvoir exécuter du code ou un programme si celle-ci s'interrompt.
					Un outil de débogage peut également se connecter à une
                    <abbr title="Java Virtual Machine">JVM</abbr>
                    bloquée ou son fichier principal à l'aide d'un "HotSpot JVM serviceability agent connector".
                </p>
                <code>-XX:OnError="command"
					-XX:OnError="pmap %p"
					-XX:OnError="gdb %p"
					optional %p used as process id</code>
            </div>
            <a name="dc" />
        </div>
        <div class="chapter">
            <h2>Desktop Client</h2>
            <p>Java Desktop client est un composant clé de la plate-forme Java et a été sujet à de nombreuses améliorations dans J2SE 5.0.</p>
            <p>Les versions beta de J2SE 5.0 bénéficient déjà d'un démarrage plus rapide et d'une charge mémoire allégée.
				Un nouveau thème a également été ajouté, dont le nom est Ocean. Les Look and Feel GTK et Windows XP ont également été améliorés :</p>
            <table align="center" border="0" cellpadding="0" cellspacing="15" width="155">
                <tbody>
                    <tr>
                        <td>
                            <table class="grey3" align="center" border="0" cellpadding="8" cellspacing="2" width="155">
                                <tbody>
                                    <tr>
                                        <td align="center" bgcolor="#ffffff">
                                            <a href="http://java.sun.com/developer/technicalArticles/releases/j2se15/15art2.jpg">
                                                <img src="./images/15art2_sm.gif" alt="Windows XP" border="0" height="114" width="154" />
                                            </a>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td align="center">
                                            <div class="pad3">
                                                <span class="dkcaption1">
                                                    Windows XP
                                                    <br />
                                                    <a href="http://java.sun.com/developer/technicalArticles/releases/j2se15/15art2.jpg">Cliquez pour agrandir</a>
                                                </span>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </td>
                        <td>
                            <table class="grey3" align="center" border="0" cellpadding="8" cellspacing="2" width="155">
                                <tbody>
                                    <tr>
                                        <td align="center" bgcolor="#ffffff">
                                            <a href="http://java.sun.com/developer/technicalArticles/releases/j2se15/15art1.jpg">
                                                <img src="./images/15art1_sm.gif" alt="Linux/Redhat" border="0" height="114" width="154" />
                                            </a>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td align="center">
                                            <div class="pad3">
                                                <span class="dkcaption1">
                                                    Linux/RedHat
                                                    <br />
                                                    <a href="http://java.sun.com/developer/technicalArticles/releases/j2se15/15art1.jpg">Cliquez pour agrandir</a>
                                                </span>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </td>
                    </tr>
                </tbody>
            </table>
            <p>Les utilisateurs de Linux, Solaris et Windows peuvent dès à présent bénéficier de l'accélération matérielle OpenGL de leurs pilotes graphiques
				avec les applications Java2D, en utilisant l'option suivante à l'exécution :</p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">java -Dsun.java2d.opengl=true -jar Java2D.jar</span>
            </div>
            <p>La version Linux de J2SE 5.0 utilise un kit d'affichage X11 rapide, appelé XAWT qui est activé par défaut. Si vous désirez comparer avec la version Motif,
				vous pouvez le faire avec :</p>
            <div class="subChapter">
                <span class="cmd_line_lvl">$&gt;</span>
                <span class="cmd_line">java -Dawt.toolkit=sun.awt.motif.MToolkit -jar Notepad.jar</span>
            </div>
            <p>
                (le kit d'affichage X11 est appelé
                <code>sun.awt.X11.XToolkit</code>
                )
            </p>
            <p>Le kit d'affichage X11 utilise également le protocole XDnD afin que vous puissiez glisser-déplacer de composants simples entre
				des applications Java et d'autres comme StarOffice ou Mozilla.</p>
            <a name="misc" />
        </div>
        <div class="chapter">
            <h2>Fonctions diverses</h2>
            <div class="subChapter">
                <h3>Support XML intégré</h3>
                <p>
                    J2SE 5.0 inclut différents composant d'
                    <abbr title="eXtensible Markup Language">XML</abbr>
                    , comme une gestion de sa version 1.1 avec espaces de nommage (namespaces),
					des schémas XML, SAX 2.0.2, Document Object Level niveau 3, et
                    <abbr title="XSL Transformations">XSLT</abbr>
                    avec un compilateur XLSTC rapide.
                </p>
                <p>En plus de ces points-là, les prochaines version de Java Web Services Developer Pack pourront gérer les derniers standards
					en matière de web services : JAX-RPC &amp; SAAJ (WSDL/SOAP), JAXB, l'encryptage XML, les signatures digitales et JAXR.</p>
            </div>
            <div class="subChapter">
                <h3>Support des caractères supplémentaires</h3>
                <p>Des caractères 32 bits supplémentaires ont été rajoutés à la plate-forme, afin de commencer la transition vers un support Unicode 4.0.
					Ces caractères supplémentaires sont encodés sous forme de couples spéciaux de valeurs UTF16, afin de générer d'autres caractères.
					Un tel couple de substitution est composé d'une valeur haute UTF16, suivie d'une valeur faible UTF16. Des valeurs hautes et faibles UTF16
					sont des catégories UTF16 spéciales.</p>
                <p>Les API Java peuvent gérer de façon transparente ces caractères supplémentaires sans que vous ayez à vous en soucier.
					Par contre, le type primitif « char » reste encodé sur 16 bits, le peu de méthodes qui utilisait des « char » en arguments
					disposent maintenant de méthodes acceptant une valeur entière représentant la nouvelle valeur. La classe Character possède par exemple
					des méthodes supplémentaires permettant de récupérer le caractère courant ainsi que le suivant afin de récupérer cette valeur supplémentaire :</p>
                <textarea name="code" class="java">String u = "\uD840\uDC08";
					System.out.println(u + "+ " + u.length());
					System.out.println(Character.isHighSurrogate(u.charAt(0)));
					System.out.println((int) u.charAt(1));
					System.out.println((int) u.codePointAt(0));</textarea>
                <p>
                    Référez-vous à la section
                    <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Character.html" target="_blank">Unicode</a>
                    pour plus de détails.
                </p>
            </div>
            <div class="subChapter">
                <h3>RowSets JDBC</h3>
                <p>Il existe cinq nouvelles implémentations de classes JDBC RowSet avec cette nouvelle version. Les plus importantes sont les interfaces CachedRowSet et WebRowSet.
					Des objets RowSet, contrairement aux objets ResultSet, permettent d'opérer sans pour autant rester connecté à la base de données pendant
					le temps de manipulation des données. Grâce au gain apporté par le fait de ne pas maintenir active une connexion à une source de données,
					les classes les implémentant ces interfaces sont moins lourdes que les objets ResultSet. Un objet CachedRowSet contient une collection interne      des lignes récupérées à partir de la source de données et peut, si nécessaire, être synchronisée ultérieurement avec celle-ci.
					Un objet WebRowSet se comporte de la même manière avec l'avantage de pouvoir lire et écrire des données au format XML.</p>
                <p>Le code suivant montre la facilité d'utilisation d'un objet WebRowSet :</p>
                <textarea name="code" class="java">Class.forName("org.postgresql.Driver");
					WebRowSetImpl wrs = new WebRowSetImpl();
					wrs.setCommand("SELECT COF_NAME,TOTAL FROM COFFEES");
					wrs.setUsername("postgres");
					wrs.setPassword("");
					wrs.setUrl("jdbc:postgresql:test");
					wrs.execute(); // exécute la commande et remplit le WebRowSet à partir de COFFEES
					wrs.absolute(1); // déplace le curseur à la première ligne de wrs
					wrs.updateInt(2, 10); // change la valeur de la colonne TOTAL à 10
					wrs.updateRow(); // arrête la mise à jour de la ligne
					wrs.acceptChanges(); // écrit le nouveau total sur la source de données
					wrs.writeXml(System.out); // et exporte les données au format XML
					wrs.close();</textarea>
            </div>
        </div>
        <div class="chapter">
            <h2>References</h2>
            <p>
                New Language Features for Ease of Development in the Java 2
				Platform Standard Edition 5.0:
                <a href="http://java.sun.com/features/2003/05/bloch_qa.html" target="_blank">http://java.sun.com/features/2003/05/bloch_qa.html</a>
            </p>
            <div class="subChapter">
                <h3>Tiger Component JSRs</h3>
                <p>
                    003 Java Management Extensions (JMX) Specification
                    <a href="http://jcp.org/en/jsr/detail?id=3" target="_blank">http://jcp.org/en/jsr/detail?id=3</a>
                </p>
                <p>
                    013 Decimal Arithmetic Enhancement
                    <a href="http://jcp.org/en/jsr/detail?id=13" target="_blank">http://jcp.org/en/jsr/detail?id=13</a>
                </p>
                <p>
                    014 Add Generic Types To The Java Programming Language
                    <a href="http://jcp.org/en/jsr/detail?id=14" target="_blank">http://jcp.org/en/jsr/detail?id=14</a>
                </p>
                <p>
                    028 Java SASL Specification
                    <a href="http://jcp.org/en/jsr/detail?id=28" target="_blank">http://jcp.org/en/jsr/detail?id=28</a>
                </p>
                <p>
                    114 JDBC Rowset Implementations
                    <a href="http://jcp.org/en/jsr/detail?id=114" target="_blank">http://jcp.org/en/jsr/detail?id=114</a>
                </p>
                <p>
                    133 Java Memory Model and Thread Specification Revision
                    <a href="http://jcp.org/en/jsr/detail?id=133" target="_blank">http://jcp.org/en/jsr/detail?id=133</a>
                </p>
                <p>
                    160 Java Management Extensions (JMX) Remote API 1.0
                    <a href="http://jcp.org/en/jsr/detail?id=160" target="_blank">http://jcp.org/en/jsr/detail?id=160</a>
                </p>
                <p>
                    163 Java Platform Profiling Architecture
                    <a href="http://jcp.org/en/jsr/detail?id=163" target="_blank">http://jcp.org/en/jsr/detail?id=163</a>
                </p>
                <p>
                    166 Concurrency Utilities
                    <a href="http://jcp.org/en/jsr/detail?id=166" target="_blank">http://jcp.org/en/jsr/detail?id=166</a>
                </p>
                <p>
                    174 Monitoring and Management Specification for the Java Virtual Machine
                    <a href="http://jcp.org/en/jsr/detail?id=174" target="_blank">http://jcp.org/en/jsr/detail?id=174</a>
                </p>
                <p>
                    175 A Metadata Facility for the Java Programming Language
                    <a href="http://jcp.org/en/jsr/detail?id=175" target="_blank">http://jcp.org/en/jsr/detail?id=175</a>
                </p>
                <p>
                    200 Network Transfer Format for Java Archives
                    <a href="http://jcp.org/en/jsr/detail?id=200" target="_blank">http://jcp.org/en/jsr/detail?id=200</a>
                </p>
                <p>
                    201 Extending the Java Programming Language with Enumerations, Autoboxing, Enhanced for Loops and Static Import
                    <a href="http://jcp.org/en/jsr/detail?id=201" target="_blank">http://jcp.org/en/jsr/detail?id=201</a>
                </p>
                <p>
                    204 Unicode Supplementary Character Support
                    <a href="http://jcp.org/en/jsr/detail?id=204" target="_blank">http://jcp.org/en/jsr/detail?id=204</a>
                </p>
                <p>
                    206 Java API for XML Processing (JAXP) 1.3
                    <a href="http://jcp.org/en/jsr/detail?id=206" target="_blank">http://jcp.org/en/jsr/detail?id=206</a>
                </p>
                <p />
                <p>
                    Traduction de
                    <a href="http://java.sun.com/developer/technicalArticles/releases/j2se15/" target="_blank">J2SE 5.0 in a Nutshell</a>
                </p>
            </div>
        </div>
    </body>
</html>

